fix: emit structural repair patches immediately and make engine normalization the sole repairer - #3246

…lization the sole repairer

When a value entered the editor with structurally invalid content
(blocks or children without a `_key`, missing or empty `children`
arrays, duplicate keys), the engine repaired it right away but the
repair patches were parked: the editor machine's `pristine` state
deferred `internal.patch` and `mutation` events produced under
normalization until the first local edit flipped it to `dirty`.
Parked patches go stale under concurrent remote traffic (a sibling
insert shifts the indices a parked repair addresses, so the flush
re-keys the wrong node). The mutation batcher additionally dropped
pending work on a read-only unmount, `validateValue` repaired some
of the same defects before ingestion with its own patch shapes (its
insert branch never reported them), and a block missing its `_key`
failed validation into the invalid-value flow.

The parking machinery is deleted rather than gated: `writing` emits
`internal.patch`/`mutation` directly (the `pristine`/`dirty` split,
the normalization guard, and the conflict-discard actions are gone),
and events deferred during setup flush FIFO when setup completes.
Nothing keys on document pristineness anymore. The mutation batcher
keeps one gate, and it is a different kind: `patch` events relay
immediately regardless of read-only state, but mutation bulks hold
while the editor is read-only and flush on the first tick after it
becomes editable. Studio and Canvas flip the editor read-only when
the connection drops and both throw on mutations delivered while
read-only, so an ungated flush loses the edit typed just before the
flip (pinned by a test whose host listener rejects mutations while
read-only, red on the ungated batcher). The cleanup flush is
unconditional, so pending work is handed over on unmount instead of
dropped. `isDeferringMutations` counts only bulks holding a patch
accumulated while the editor was editable: repair bulks held by a
read-only editor do not latch the sync machine's busy guard, so a
read-only viewer of a malformed document keeps applying incoming
value updates (pinned red on the latching version). Held bulks
without editable-time patches are culled when inbound state applies
(value sync or remote patches settle, signalled via an emit ordered
after the pass's own repair emissions; a plain call misordered under
reentrant streamed syncs and lost the fresh re-mint, pinned red):
repairs are re-derivable, so a superseded repair is dropped rather
than delivered against state that moved past it. A remote-patches
batch culls only when it changed engine state: a full snapshot always
supersedes or re-mints a held repair, but a no-op patch batch
supersedes nothing and ran no normalization to re-mint, so it keeps
the held repair (pinned red on the ungated cull); the batch's
`changed` flag accumulates across patches instead of reflecting only
the last one. One consequence: an operation whose patches span an
inbound application splits into two mutation events.

`validateValue`'s `autoResolve` resolutions are deleted with their
reporting machinery (`applyAutoResolution`, the sync actor's
out-of-band `patch` channel); validation passes mechanically fixable
shapes through and engine normalization repairs them on intake,
emitting engine-shaped patches with `origin: 'local'` (minimal `set`
on the minted `_key`, placeholder-span `insert` before
`children[0]`). `updateBlock` gains a wholesale-set fallback for raw
input: children arrays containing keyless children, or a raw empty
`children` replacing populated children, are set wholesale instead
of reconciled per child, so no `{_key: undefined}` path segment is
ever applied; normalization then mints the keys.

The invalid-value flow remains for defects that need a human (a
non-object block, an unknown `_type`, a span whose `text` is not a
string), and its resolutions address the defective block truthfully:
block anchors resolve through `nodeSegment` (numeric index when the
key is unusable, instead of `{_key: undefined}`, which keyed
matching would resolve to the first keyless sibling), and
`validateValue` takes the block's base index so paths and
descriptions carry the block's document position rather than its
position in the one-block slice `syncBlock` validates (previously
always 0: applying such a resolution rewrote the first block).

Deliberate changes: orphaned `markDefs` are no longer pruned at
intake (the engine's prune is local-only by the two-class model);
they go when a local edit next dirties the block, as a `set` of the
filtered array. Sync `insert` operations carry the raw block, and
normalization repairs follow as their own operations. A snapshot
echoing a still-keyless copy of an already-repaired block re-mints
on the next sync: whole-value sync has no key to correlate an echo
by. Cosmetic normalization (span merging, `markDefs`/`style`/`marks`
defaults) still materializes at the first local edit.
`InvalidValueResolution.autoResolve` is deprecated, never set.